// pages/task_detail/task_detail.js
const request = require('../../utils/promise.js');
Page({
  /**
   * 页面的初始数据
   */
  data: {
    taskId: 0,
    taskObj: {},
    isTaskComplete: true, // 任务完成状态（已完成的任务不允许修改） true：已完成 flase：未完成    
    userId: null,
    userStatusObj: {
      isRecieve: true, // 是否领取
      isComplete: true, // 是否完成
      isManager: false, // 是否管理者(负责人)
    },
    taskStatusArray: [ // 任务状态 1：未发布 2：运行 3：暂停 4：完成 5：关闭
      {value: 1, label: '未发布'},
      {value: 2, label: '运行'},
      {value: 3, label: '暂停'},
      {value: 4, label: '完成'},
      {value: 5, label: '关闭'}
    ],
    taskIndex: 0, // 任务picker的下标
  },

  /**
   * 生命周期函数--监听页面加载
   */
  onLoad: function (options) {
    this.setData({
      taskId: options.id,
      userId: wx.getStorageSync('userId')
    })
  },

  /**
   * 生命周期函数--监听页面显示
   */
  onShow: function () {
    this.initTaskData();
  },

  /**
   * 页面被用户分享时执行
   */
  onShareAppMessage() {
    return {
      title: '任务详情'
    }
  },

  /**
   * 分享到朋友圈
   */
  onShareTimeline() {
    return {
      title: '任务详情'
    }
  },

  /**
   * 根据 id 获取任务详情
   */
  initTaskData() {
    request.GET('/task/getTaskById', {taskId: this.data.taskId}).then(res => {
      this.setData({
        taskObj: res.data
      });

      // 如果任务状态为完成与关闭，则不可编辑
      let taskStatus = res.data.taskStatus;
      if (taskStatus==4 || taskStatus==5) {
        this.setData({
          isTaskComplete: true
        });
      } else {
        this.setData({
          isTaskComplete: false
        });
      }

      // 获得下标，初始化picker的默认值
      let taskIndex = (this.data.taskStatusArray || []).findIndex((item) => item.value == taskStatus);
      this.setData({
        taskIndex: taskIndex
      });
    });

    // 获取该任务的用户状态
    request.GET("/task/getTaskUserStatus", {taskId: this.data.taskId, userId: this.data.userId}).then(res => {
      // isRecieve isComplete isManager
      // console.log(res)
      this.setData({
        userStatusObj: res.data
      })
    })
  },

  /**
   * 修改切换状态
   */
  bindPickerChange(e) {

    let newIndex = e.detail.value;
    let oldValue = this.data.taskObj.taskStatus;
    let changeValue = this.data.taskStatusArray[newIndex].value;

    // 任务状态，修改前后相同的情况
    if (oldValue==changeValue) {
      wx.showToast({
        title: '任务状态相同，无需修改',
        icon: 'none',
        duration: 2000
      })
      return;
    }
    // 未发布状态的任务，无法直接暂停，需要选择运行后再暂停
    if (oldValue==1 && changeValue==3) {
      wx.showModal({
        title: '温馨提示',
        content: '未发布状态的任务，无法直接暂停，需要选择运行后再暂停',
        showCancel: false
      })
      return;
    }

    // 未发布状态的任务，无法直接完成，可以选择关闭
    if (oldValue==1 && changeValue==4) {
      wx.showModal({
        title: '温馨提示',
        content: '未发布状态的任务，无法直接完成，可以选择关闭',
        showCancel: false
      })
      return;
    }

    // 已运行或暂停的任务，无法改回 未完成状态
    if ((oldValue==2 || oldValue==3) && changeValue==1) {
      wx.showModal({
        title: '温馨提示',
        content: '已运行或暂停的任务，无法改回 未完成状态',
        showCancel: false
      })
      return;
    }

    // picker下标修改
    this.setData({
      taskIndex: newIndex
    })

    let param = {
      taskId: this.data.taskId,
      taskStatus: changeValue,
      userId: this.data.userId
    }
    let that = this;
    request.POST('/task/updateTaskStatus', param).then(res => {
      if (res.statusCode == 200) {
        wx.showToast({
          title: '保存成功',
          icon: 'none',
          duration: 1000
        })
        that.initTaskData();
      } else {
        wx.showToast({
          title: '保存异常失败',
          icon: 'error',
          duration: 1500
        })
      }
    })
  },

  gotoUpdateDesc() {
    wx.navigateTo({
      url: '/pages/task_edit/task_edit?taskId=' + this.data.taskId
      + '&taskName=' + this.data.taskObj.taskName
      + '&isTaskComplete=' + this.data.isTaskComplete
      + '&isManager=' + this.data.userStatusObj.isManager
    })
    wx.setStorageSync('taskDesc', this.data.taskObj.taskDesc);
  },

  /**
   * 点击任务讨论
   */
  clickViewForum() {
    wx.navigateTo({
      url: '/pages/task_forum/task_forum?taskId=' + this.data.taskId +'&canIAddForum='+ (this.data.userStatusObj['isRecieve']? 1: 0),
    })
  },

  /**
   * 点击任务进度
   */
  clickViewProgress() {
    wx.navigateTo({
      url: '/pages/task_progress/task_progress?taskId=' + this.data.taskId,
    })
  },

  /**
   * 领取任务
   */
  getTask() {
    let that = this;
    wx.showModal({
      title: '确认提示',
      content: '您确认领取该任务？',
      success(res) {
        if (res.confirm) {
          const param = {
            taskId: that.data.taskId,
            userIds: [that.data.userId],
            recieveType: 0, // 自己领取任务
            createdBy: that.data.userId
          }
          request.POST('/task/createTaskUsers', param).then(res => {
            if (res.statusCode == 200) {
              wx.showToast({
                title: '领取成功',
                icon: 'success',
                duration: 1000
              })
    
              // 只刷新是否领取状态
              that.setData({
                userStatusObj: {
                  isRecieve: true,
                  isComplete: that.data.userStatusObj.isComplete,
                  isManager: that.data.userStatusObj.isManager
                }
              });
            } else {
              wx.showToast({
                title: '保存异常失败',
                icon: 'error',
                duration: 1500
              })
            }
          })
        }
      }
    });
  },

  /**
   * 完成任务
   */
  gotoCompleteTask() {
    wx.navigateTo({
      url: '/pages/task_complete/task_complete?taskId=' + this.data.taskId +'&taskName='+this.data.taskObj.taskName
    })
  },

  /**
   * 任务成员列表
   */
  gotoTaskUserList() {
    wx.navigateTo({
      url: '/pages/task_user_list/task_user_list?taskId=' + this.data.taskId 
      + '&taskName=' + this.data.taskObj.taskName
      + '&taskType=' + this.data.taskObj.taskType
      + '&isTaskComplete=' + this.data.isTaskComplete
      + '&isManager=' + this.data.userStatusObj.isManager
    })
  },

  /**
   * 页面销毁时执行 -- 返回上一页
   */
  onUnload() {
    const pages = getCurrentPages(); // 定义上页面
    const prevPage = pages[pages.length - 2]; //上一个页面
    if (prevPage) {
      let taskArr = prevPage.data.taskList;
      // undefined判断，避免返回报错
      if(taskArr == undefined){
        return;
      }

      for (let i=0; i<taskArr.length; i++) {
        if (taskArr[i]['taskId']==this.data.taskId) {
          taskArr[i]['taskStatus'] = this.data.taskObj['taskStatus'];
          break;
        }
      }
      prevPage.setData({
        taskList: taskArr
      })
    }
  },

})